home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / pluginy Firefox / 52811 / 52811.xpi / chrome / content / AES / md5.js < prev    next >
Encoding:
JavaScript  |  2009-07-03  |  9.5 KB  |  365 lines
  1. /*
  2. *  md5.jvs 1.0b 27/06/96
  3. *
  4. * Javascript implementation of the RSA Data Security, Inc. MD5
  5. * Message-Digest Algorithm.
  6. *
  7. * Copyright (c) 1996 Henri Torgemane. All Rights Reserved.
  8. *
  9. * Permission to use, copy, modify, and distribute this software
  10. * and its documentation for any purposes and without
  11. * fee is hereby granted provided that this copyright notice
  12. * appears in all copies. 
  13. *
  14. * Of course, this soft is provided "as is" without express or implied
  15. * warranty of any kind.
  16.  
  17.   This version contains some trivial reformatting modifications
  18.   by John Walker.
  19.  
  20. */
  21.  
  22. function array(n) {
  23.     for (i = 0; i < n; i++) {
  24.         this[i] = 0;
  25.     }
  26.     this.length = n;
  27. }
  28.  
  29. /* Some basic logical functions had to be rewritten because of a bug in
  30.  * Javascript.. Just try to compute 0xffffffff >> 4 with it..
  31.  * Of course, these functions are slower than the original would be, but
  32.  * at least, they work!
  33.  */
  34.  
  35. function integer(n) {
  36.     return n % (0xffffffff + 1);
  37. }
  38.  
  39. function shr(a, b) { //shift right
  40.     a = integer(a);
  41.     b = integer(b);
  42.     if (a - 0x80000000 >= 0) {
  43.         a = a % 0x80000000;
  44.         a >>= b;
  45.         a += 0x40000000 >> (b - 1);
  46.     } else {
  47.         a >>= b;
  48.     }
  49.     return a;
  50. }
  51.  
  52. function shl1(a) {
  53.     a = a % 0x80000000;
  54.     if (a & 0x40000000 == 0x40000000) {
  55.         a -= 0x40000000;  
  56.         a *= 2;
  57.         a += 0x80000000;
  58.     } else {
  59.         a *= 2;
  60.     }
  61.     return a;
  62. }
  63.  
  64. function shl(a, b) {
  65.     a = integer(a);
  66.     b = integer(b);
  67.     for (var i = 0; i < b; i++) {
  68.         a = shl1(a);
  69.     }
  70.     return a;
  71. }
  72.  
  73. function and(a, b) {
  74.     a = integer(a);
  75.     b = integer(b);
  76.     var t1 = a - 0x80000000;
  77.     var t2 = b - 0x80000000;
  78.     if (t1 >= 0) {
  79.         if (t2 >= 0) {
  80.             return ((t1 & t2) + 0x80000000);
  81.         } else {
  82.             return (t1 & b);
  83.         }
  84.     } else {
  85.         if (t2 >= 0) {
  86.             return (a & t2);
  87.         } else {
  88.             return (a & b);  
  89.         }
  90.     }
  91. }
  92.  
  93. function or(a, b) {
  94.     a = integer(a);
  95.     b = integer(b);
  96.     var t1 = a - 0x80000000;
  97.     var t2 = b - 0x80000000;
  98.     if (t1 >= 0) {
  99.         if (t2 >= 0) {
  100.             return ((t1 | t2) + 0x80000000);
  101.         } else {
  102.             return ((t1 | b) + 0x80000000);
  103.         }
  104.     } else {
  105.         if (t2 >= 0) {
  106.             return ((a | t2) + 0x80000000);
  107.         } else {
  108.             return (a | b);  
  109.         }
  110.     }
  111. }
  112.  
  113. function xor(a, b) {
  114.     a = integer(a);
  115.     b = integer(b);
  116.     var t1 = a - 0x80000000;
  117.     var t2 = b - 0x80000000;
  118.     if (t1 >= 0) {
  119.         if (t2 >= 0) {
  120.             return (t1 ^ t2);
  121.         } else {
  122.             return ((t1 ^ b) + 0x80000000);
  123.         }
  124.     } else {
  125.         if (t2 >= 0) {
  126.             return ((a ^ t2) + 0x80000000);
  127.         } else {
  128.             return (a ^ b);  
  129.         }
  130.     }
  131. }
  132.  
  133. function not(a) {
  134.     a = integer(a);
  135.     return 0xffffffff - a;
  136. }
  137.  
  138. /* Here begin the real algorithm */
  139. var state = new array(4); 
  140. var count = new array(2);
  141.     count[0] = 0;
  142.     count[1] = 0;                     
  143. var buffer = new array(64); 
  144. var transformBuffer = new array(16); 
  145. var digestBits = new array(16);
  146.  
  147. var S11 = 7;
  148. var S12 = 12;
  149. var S13 = 17;
  150. var S14 = 22;
  151. var S21 = 5;
  152. var S22 = 9;
  153. var S23 = 14;
  154. var S24 = 20;
  155. var S31 = 4;
  156. var S32 = 11;
  157. var S33 = 16;
  158. var S34 = 23;
  159. var S41 = 6;
  160. var S42 = 10;
  161. var S43 = 15;
  162. var S44 = 21;
  163.  
  164. function F(x, y, z) {
  165.     return or(and(x, y), and(not(x), z));
  166. }
  167.  
  168. function G(x, y, z) {
  169.     return or(and(x, z), and(y, not(z)));
  170. }
  171.  
  172. function H(x, y, z) {
  173.     return xor(xor(x, y), z);
  174. }
  175.  
  176. function I(x, y, z) {
  177.     return xor(y ,or(x , not(z)));
  178. }
  179.  
  180. function rotateLeft(a, n) {
  181.     return or(shl(a, n), (shr(a, (32 - n))));
  182. }
  183.  
  184. function FF(a, b, c, d, x, s, ac) {
  185.     a = a + F(b, c, d) + x + ac;
  186.     a = rotateLeft(a, s);
  187.     a = a + b;
  188.     return a;
  189. }
  190.  
  191. function GG(a, b, c, d, x, s, ac) {
  192.     a = a + G(b, c, d) + x + ac;
  193.     a = rotateLeft(a, s);
  194.     a = a + b;
  195.     return a;
  196. }
  197.  
  198. function HH(a, b, c, d, x, s, ac) {
  199.     a = a + H(b, c, d) + x + ac;
  200.     a = rotateLeft(a, s);
  201.     a = a + b;
  202.     return a;
  203. }
  204.  
  205. function II(a, b, c, d, x, s, ac) {
  206.     a = a + I(b, c, d) + x + ac;
  207.     a = rotateLeft(a, s);
  208.     a = a + b;
  209.     return a;
  210. }
  211.  
  212. function transform(buf, offset) { 
  213.     var a = 0, b = 0, c = 0, d = 0; 
  214.     var x = transformBuffer;
  215.     
  216.     a = state[0];
  217.     b = state[1];
  218.     c = state[2];
  219.     d = state[3];
  220.     
  221.     for (i = 0; i < 16; i++) {
  222.         x[i] = and(buf[i * 4 + offset], 0xFF);
  223.         for (j = 1; j < 4; j++) {
  224.             x[i] += shl(and(buf[i * 4 + j + offset] ,0xFF), j * 8);
  225.         }
  226.     }
  227.  
  228.     /* Round 1 */
  229.     a = FF( a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
  230.     d = FF( d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
  231.     c = FF( c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
  232.     b = FF( b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
  233.     a = FF( a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
  234.     d = FF( d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
  235.     c = FF( c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
  236.     b = FF( b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
  237.     a = FF( a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
  238.     d = FF( d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
  239.     c = FF( c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
  240.     b = FF( b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
  241.     a = FF( a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
  242.     d = FF( d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
  243.     c = FF( c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
  244.     b = FF( b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
  245.  
  246.     /* Round 2 */
  247.     a = GG( a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
  248.     d = GG( d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
  249.     c = GG( c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
  250.     b = GG( b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
  251.     a = GG( a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
  252.     d = GG( d, a, b, c, x[10], S22,  0x2441453); /* 22 */
  253.     c = GG( c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
  254.     b = GG( b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
  255.     a = GG( a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
  256.     d = GG( d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
  257.     c = GG( c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
  258.     b = GG( b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
  259.     a = GG( a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
  260.     d = GG( d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
  261.     c = GG( c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
  262.     b = GG( b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
  263.  
  264.     /* Round 3 */
  265.     a = HH( a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
  266.     d = HH( d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
  267.     c = HH( c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
  268.     b = HH( b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
  269.     a = HH( a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
  270.     d = HH( d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
  271.     c = HH( c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
  272.     b = HH( b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
  273.     a = HH( a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
  274.     d = HH( d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
  275.     c = HH( c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
  276.     b = HH( b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
  277.     a = HH( a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
  278.     d = HH( d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
  279.     c = HH( c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
  280.     b = HH( b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
  281.  
  282.     /* Round 4 */
  283.     a = II( a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
  284.     d = II( d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
  285.     c = II( c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
  286.     b = II( b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
  287.     a = II( a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
  288.     d = II( d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
  289.     c = II( c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
  290.     b = II( b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
  291.     a = II( a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
  292.     d = II( d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
  293.     c = II( c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
  294.     b = II( b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
  295.     a = II( a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
  296.     d = II( d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
  297.     c = II( c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
  298.     b = II( b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
  299.  
  300.     state[0] += a;
  301.     state[1] += b;
  302.     state[2] += c;
  303.     state[3] += d;
  304.  
  305. }
  306.  
  307. function md5_init() {
  308.     count[0] = count[1] = 0;
  309.     state[0] = 0x67452301;
  310.     state[1] = 0xefcdab89;
  311.     state[2] = 0x98badcfe;
  312.     state[3] = 0x10325476;
  313.     for (i = 0; i < digestBits.length; i++) {
  314.         digestBits[i] = 0; //azzera l'array
  315.     }
  316. }
  317.  
  318. function md5_update(b) { 
  319.     var index, i;
  320.     
  321.     index = and(shr(count[0],3) , 0x3F);
  322.     if (count[0] < 0xFFFFFFFF - 7) {
  323.       count[0] += 8;
  324.     } else {
  325.       count[1]++;
  326.       count[0] -= 0xFFFFFFFF + 1;
  327.       count[0] += 8;
  328.     }
  329.     buffer[index] = and(b, 0xff);
  330.     if (index  >= 63) {
  331.         transform(buffer, 0);
  332.     }
  333. }
  334.  
  335. function md5_finish() {
  336.     var bits = new array(8);
  337.     var padding; 
  338.     var i = 0, index = 0, padLen = 0;
  339.  
  340.     for (i = 0; i < 4; i++) {
  341.         bits[i] = and(shr(count[0], (i * 8)), 0xFF);
  342.     }
  343.     for (i = 0; i < 4; i++) {
  344.         bits[i + 4] = and(shr(count[1], (i * 8)), 0xFF);
  345.     }
  346.     index = and(shr(count[0], 3), 0x3F);
  347.     padLen = (index < 56) ? (56 - index) : (120 - index);
  348.     padding = new array(64); 
  349.     padding[0] = 0x80;
  350.     for (i = 0; i < padLen; i++) {
  351.       md5_update(padding[i]);
  352.     }
  353.     for (i = 0; i < 8; i++) {
  354.       md5_update(bits[i]);
  355.     }
  356.  
  357.     for (i = 0; i < 4; i++) {
  358.         for (j = 0; j < 4; j++) {
  359.             digestBits[i * 4 + j] = and(shr(state[i], (j * 8)) , 0xFF);
  360.         }
  361.     } 
  362. }
  363.  
  364. /* End of the MD5 algorithm */
  365.